// 云对象调用工具 - 完全使用云对象实现并兼容request.js

// 云对象缓存池，避免重复实例化
const cloudObjectCache = new Map();

/**
 * 使用正则表达式将路径转换为方法名
 * @param {string[]} paths - 路径字符串数组，如 ['api', 'index', 'ads']
 * @returns {string} 转换后的方法名，如 'apiIndexAds'
 */
function pathToMethodName(paths) {
    if (!paths || paths.length === 0) return '';
    return paths
        .map((path, index) => index === 0 ? path.charAt(0).toLowerCase() + path.slice(1) : path.charAt(0).toUpperCase() + path.slice(1))
        .join('');
}

/**
 * 解析URL路径获取云对象名和方法名
 * @param {string} url - 完整URL路径，如 '/index/index/ads'
 * @returns {object} 包含cloudObjectName和methodName的对象
 */
function parseCloudPath(url) {
    if (!url) {
        throw new Error('URL不能为空');
    }

    // 移除开头的斜杠
    const normalizedUrl = url.startsWith('/') ? url.slice(1) : url;

    // 分割路径获取云对象名和API路径
    const pathParts = normalizedUrl.split('/');
    if (pathParts.length < 1) {
        throw new Error('URL格式错误');
    }

    // 第一个段为云对象名，剩余段为方法路径
    const cloudObjectName = pathParts[0];
    const methodPath = pathParts.slice(1);

    // 转换为驼峰命名的方法名
    const methodName = pathToMethodName(methodPath);
    return {
        cloudObjectName,
        methodName
    };
}

/**
 * 获取云对象实例，支持缓存
 * @param {string} cloudObjectName - 云对象名称
 * @returns {object} 云对象实例
 */
function getCloudObject(cloudObjectName) {
    if (!cloudObjectCache.has(cloudObjectName)) {
        try {
            // 创建云对象实例并缓存
            const cloudObject = uniCloud.importObject(cloudObjectName);
            cloudObjectCache.set(cloudObjectName, cloudObject);
        } catch (error) {
            console.error(`导入云对象 ${cloudObjectName} 失败:`, error);
            throw error;
        }
    }
    return cloudObjectCache.get(cloudObjectName);
}

/**
 * 调用云对象方法
 * @param {string} url - API路径
 * @param {object} params - 请求参数
 * @param {string} method - 请求方法（GET/POST）
 * @returns {Promise} 请求结果Promise
 */
async function callCloudFunction(url, params = {}, method = 'POST') {
    try {
        // 解析路径获取云对象名和方法名
        const { cloudObjectName, methodName } = parseCloudPath(url);
        // 获取云对象实例
        const cloudObject = getCloudObject(cloudObjectName);
        // 如果方法名为空，则使用默认方法名（如直接使用云对象名称）
        const finalMethodName = methodName || 'index';
        
        // 检查方法是否存在
        if (typeof cloudObject[finalMethodName] !== 'function') {
            throw new Error(`云对象 ${cloudObjectName} 中不存在方法 ${finalMethodName}`);
        }
        
        // 添加请求方法类型
        if (method) {
            params._method = method;
        }
        var promise = new Promise((resolve, reject) => {
            cloudObject[finalMethodName](params).then(res => {
                if (res.code == 1 || res.code == 200) {
                    resolve(res);
                } else {
                    reject(res)
                } 
            })
        })
        return promise;
    } catch (error) {
        console.error('云对象调用失败:', error);
        return Promise.reject(error);
    }
}

/**
 * 创建云API代理对象，支持链式调用
 * @returns {object} 云API代理对象
 */
function createCloudApiProxy() {
    const proxy = {};
    let currentPath = '';
    
    // 创建代理函数
    const handler = {
        get(target, prop) {
            // 如果是then方法，说明在Promise链中，执行调用
            if (prop === 'then') {
                return function(onFulfilled, onRejected) {
                    return callCloudFunction(currentPath).then(onFulfilled, onRejected);
                };
            }
            
            // 如果是catch方法
            if (prop === 'catch') {
                return function(onRejected) {
                    return callCloudFunction(currentPath).catch(onRejected);
                };
            }
            
            // 如果是exec方法，执行调用
            if (prop === 'exec') {
                return function(params = {}, method = 'POST') {
                    return callCloudFunction(currentPath, params, method);
                };
            }
            
            // 其他属性作为路径的一部分
            const newPath = currentPath ? `${currentPath}/${prop}` : prop;
            
            // 创建新的代理对象，保持链式调用
            const newProxy = createCloudApiProxy();
            newProxy._path = newPath;
            
            return newProxy;
        }
    };
    
    // 设置当前路径
    Object.defineProperty(proxy, '_path', {
        get() { return currentPath; },
        set(value) { currentPath = value; }
    });
    
    return new Proxy(proxy, handler);
}

/**
 * 批量调用云对象方法
 * @param {Array} calls - 调用配置数组 [{url, params, method}]}
 * @returns {Promise} 包含所有调用结果的Promise
 */
function batchCall(calls) {
    if (!Array.isArray(calls)) {
        return Promise.reject(new Error('批量调用参数必须是数组'));
    }
    
    const promises = calls.map(call => {
        return callCloudFunction(call.url, call.params || {}, call.method || 'POST');
    });
    
    return Promise.all(promises);
}


/**
 * POST请求方法 - 兼容utils/request/index.js
 * @param {string} url - API路径
 * @param {object} params - 请求参数
 * @returns {Promise} 请求结果Promise
 */
function postRequest(url, params = {}) {
    return callCloudFunction(url, params, 'POST');
}

/**
 * GET请求方法 - 兼容utils/request/index.js
 * @param {string} url - API路径
 * @param {object} params - 请求参数
 * @returns {Promise} 请求结果Promise
 */
function getRequest(url, params = {}) {
    return callCloudFunction(url, params, 'GET');
}


module.exports = {
    cloud: callCloudFunction,
    post: postRequest,
    get: getRequest,
    // 导出额外的功能供直接使用
    createCloudApiProxy,
    batchCall
};